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": "",