Adds support for the Haskell programming language

data/playground/haskell/RFC.hs

@@ -0,0 +1,20 @@
+-- RFC 1: What should "arg" match?
+fst :: (a, b) -> a
+fst tup@(x, y) = x
+--  ^^^^^^^^^^     <- 🎉 the whole pattern
+--  ^^^            <- 👀 only the name of the whole argument, if given
+--  ^^^  ^  ^      <- 🚀 all names in the pattern
+
+-- RFC 2: What should "branch" match?
+foo = bar
+  where
+    bar = 1
+--   🎉 `foo = bar` and `bar = 1`
+--   👀 `foo = bar where bar = 1`
+--   🚀 `foo = bar where bar = 1` and `bar = 1`
+
+-- RFC 3: What should "condition" match?
+bap :: Int -> Int
+bap | 1 == 1, 2 == 2 = undefined
+--   🎉 `1 == 1` and `2 == 2`
+--   👀 `1 == 1, 2 == 2`

data/playground/haskell/branch.hs

@@ -0,0 +1,46 @@
+data a :*: b = a :*: b
+type a :+: b = Either a b
+
+fst :: a :*: b -> a
+fst (a :*: b) = a
+
+pair a b = a :*: b
+
+fromLeft :: a :+: b -> a
+fromLeft (Left a) = a
+fromLeft _ = undefined
+
+fib :: Integer -> Integer
+fib 0 = 0
+fib 1 = 1
+fib n = fib (n-1) + fib (n-2)
+
+abs :: Int -> Int
+abs x
+    | x >= 0    =  x
+    | otherwise = -x
+
+bap :: Int -> Int
+bap x
+    | x > 0, x == 0 =  x
+    | otherwise = -x
+
+compare :: Int -> Int -> Ordering
+compare x y
+    | x <  y = LT
+    | x == y = EQ
+    | x  > y = GT
+
+fromEither :: (a -> c) -> (b -> c) -> Either a b -> c
+fromEither f g x = case x of
+    Left  l -> f l
+    Right r -> g r
+
+someFunction x (y1 : y2 : ys) (a, b, (c, [d])) = undefined
+
+compose :: (a -> b) -> (b -> c) -> (a -> c)
+compose f g x = g (f x)
+
+zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
+zipWith f [] [] = []
+zipWith f (x : xs) (y : ys) = f x y : zipWith f xs ys

data/playground/haskell/namedFunction.hs

@@ -0,0 +1,30 @@
+one :: Integer
+one = 1
+
+type MyInt = Int
+
+fib :: Integer -> Integer
+fib 0 = 0
+fib 1 = 1
+fib n = fib (n-1) + fib (n-2)
+
+not True = False
+not False = True
+
+wot True = 1
+wot False = crash
+    where
+        crash = undefined
+
+zot = undefined
+
+pot :: a
+pot =
+    let kettle = undefined
+    in kettle
+
+lot = undefined
+
+type MyDouble = Double
+
+dot = undefined

packages/common/src/extensionDependencies.ts

@@ -7,6 +7,7 @@ export const extensionDependencies = [
   "mrob95.vscode-talonscript", // talon
   "jrieken.vscode-tree-sitter-query", // scm
   "mathiasfrohlich.kotlin", // kotlin
+  "justusadam.language-haskell", // haskell
 
   // Necessary for the `drink cell` and `pour cell` tests
   "ms-toolsai.jupyter",

packages/common/src/scopeSupportFacets/haskell.ts

@@ -0,0 +1,84 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import type { LanguageScopeSupportFacetMap } from "./scopeSupportFacets.types";
+import { ScopeSupportFacetLevel } from "./scopeSupportFacets.types";
+
+const { supported, unsupported, notApplicable } = ScopeSupportFacetLevel;
+
+export const haskellScopeSupport: LanguageScopeSupportFacetMap = {
+  list: unsupported,
+  map: unsupported,
+  ifStatement: unsupported,
+  regularExpression: unsupported,
+  switchStatementSubject: unsupported,
+  fieldAccess: unsupported,
+
+  statement: unsupported,
+  "statement.iteration.document": unsupported,
+  "statement.iteration.block": unsupported,
+
+  class: unsupported,
+  // "class.instance": unsupported,
+  className: unsupported,
+
+  namedFunction: unsupported,
+  "namedFunction.method": unsupported,
+  anonymousFunction: unsupported,
+  functionName: unsupported,
+
+  functionCall: unsupported,
+  "functionCall.constructor": unsupported,
+  functionCallee: unsupported,
+  "functionCallee.constructor": unsupported,
+
+  "argument.actual": unsupported,
+  "argument.actual.iteration": unsupported,
+  "argument.formal": unsupported,
+  "argument.formal.iteration": unsupported,
+
+  "comment.line": unsupported,
+  "comment.block": unsupported,
+
+  "string.singleLine": unsupported,
+
+  "branch.match": unsupported,
+  "branch.match.iteration": unsupported,
+  "branch.if": unsupported,
+  "branch.if.iteration": unsupported,
+  "branch.ternary": unsupported,
+
+  "condition.if": unsupported,
+  "condition.ternary": unsupported,
+
+  "name.assignment": unsupported,
+  "name.assignment.pattern": unsupported,
+  "name.function": unsupported,
+  "name.class": unsupported,
+  "name.field": unsupported,
+
+  "key.mapPair": unsupported,
+  "key.mapPair.iteration": unsupported,
+
+  "value.assignment": unsupported,
+  "value.mapPair": unsupported,
+  "value.mapPair.iteration": unsupported,
+  "value.return": unsupported,
+  "value.return.lambda": unsupported,
+  "value.field": unsupported,
+
+  // "type.adt": unsupported,
+  // "type.alias": unsupported,
+  // "type.annotation": unsupported,
+  // "type.constraint": unsupported,
+  // "type.dataFamily": unsupported,
+  // "type.dataInstance": unsupported,
+  // "type.field": unsupported,
+  // "type.foreignExport": unsupported,
+  // "type.foreignImport": unsupported,
+  // "type.formalParameter": unsupported,
+  // "type.function": unsupported,
+  // "type.gadt": unsupported,
+  // "type.newtype": unsupported,
+  // "type.typeFamily": unsupported,
+  // "type.typeInstance": unsupported,
+};

packages/common/src/scopeSupportFacets/languageScopeSupport.ts

@@ -5,6 +5,7 @@ import { cppScopeSupport } from "./cpp";
 import { csharpScopeSupport } from "./csharp";
 import { cssScopeSupport } from "./css";
 import { goScopeSupport } from "./go";
+import { haskellScopeSupport } from "./haskell";
 import { htmlScopeSupport } from "./html";
 import { javaScopeSupport } from "./java";
 import { javascriptScopeSupport } from "./javascript";
@@ -36,6 +37,7 @@ export const languageScopeSupport: StringRecord<LanguageScopeSupportFacetMap> =
     csharp: csharpScopeSupport,
     css: cssScopeSupport,
     go: goScopeSupport,
+    haskell: haskellScopeSupport,
     html: htmlScopeSupport,
     java: javaScopeSupport,
     javascript: javascriptScopeSupport,

packages/common/src/scopeSupportFacets/scopeSupportFacetInfos.ts

@@ -299,6 +299,16 @@ export const scopeSupportFacetInfos: Record<
     scopeType: "disqualifyDelimiter",
   },
 
+  "branch.match": {
+    description: "A pattern match branch",
+    scopeType: "branch",
+  },
+  "branch.match.iteration": {
+    description:
+      "Iteration scope for pattern match branches; should be the entire branch",
+    scopeType: "branch",
+    isIteration: true,
+  },
   "branch.if": {
     description: "An if/elif/else branch",
     scopeType: "branch",
@@ -308,7 +318,6 @@ export const scopeSupportFacetInfos: Record<
       "A for / while loop branch. For most languages there will just be one branch for the entire loop, but eg in Python you can have an else branch for a loop.",
     scopeType: "branch",
   },
-
   "branch.if.iteration": {
     description:
       "Iteration scope for if/elif/else branch; should be the entire if-else statement",

packages/common/src/scopeSupportFacets/scopeSupportFacets.types.ts

@@ -81,6 +81,8 @@ export const scopeSupportFacets = [
 
   "disqualifyDelimiter",
 
+  "branch.match",
+  "branch.match.iteration",
   "branch.if",
   "branch.if.iteration",
   "branch.try",

packages/cursorless-vscode-e2e/package.json

@@ -13,7 +13,8 @@
   "scripts": {
     "compile": "tsc --build",
     "watch": "tsc --build --watch",
-    "clean": "rm -rf ./out tsconfig.tsbuildinfo ./dist ./build"
+    "clean": "rm -rf ./out tsconfig.tsbuildinfo ./dist ./build",
+    "generate-scope-tests-for-haskell": "my-ts-node src/scripts/generateScopeTestsForHaskell.mts"
   },
   "keywords": [],
   "author": "",