Haskell

cotrVarDouble

Haskell Create Double Variable

let ${1:myDouble} = ${2:0.0}

cotrVarList

Haskell Create List Variable

let ${1:myList} = [${2:items}]

cotrFuncArgsNamed

Haskell Named Arguments (Alternative)

-- Haskell does not have named arguments in the traditional sense.
-- You can use record syntax or higher-order functions to achieve similar functionality.

cotrTypesList

Haskell List Type

[a]

cotrVarSyntax

Haskell Variable Declaration Syntax

-- Haskell Variable Declaration Syntax:

-- - let: (Scope: Block)
--   - Declares an immutable variable.
--   - Use for values that should not change.

-- - let (mut) varName = expression: (Scope: do block)
--   - Declares a mutable variable within a 'do' block.
--   - Use for variables that need to be reassigned.

-- Note:
-- - Haskell emphasizes immutability, so use 'let' by default.
-- - Use mutable variables with 'let (mut)' only when necessary within 'do' blocks.

cotrFuncSyntax

Haskell Function Syntax

-- Haskell Function Syntax:

-- Basic function:
-- functionName :: parameterTypes -> returnType
-- functionName parameters = expression

-- Function with arguments:
-- functionName arg1 arg2 ... = expression

cotrTypeConvert

Haskell Type Conversion

-- Haskell emphasizes explicit type conversions for safety.

-- Explicit conversions:
-- - fromIntegral variable  // Converts numeric types (e.g., Int to Double)
-- - show variable  // Converts values to strings
-- - read variable  // Converts strings to values (unsafe)

-- Note:
-- - Be cautious with type conversions, especially 'read', as they can lead to errors if the conversion is not valid.

cotrVarNum

Haskell Number Variable

let ${1:myNum} :: ${2:NumType} = $3

cotrVarStringMulti

Haskell Create Multi-Line String Variable

let ${1:myString} = """
${2:Line 1}
${3:Line 2}
${4:Line 3}
"""

cotrPrintMulti

Haskell Print Multi

putStrLn $ unlines [
  ${1:"Line 1"},
  ${2:"Line 2"},
  ${3:"Line 3"}
]

cotrCommentMulti

Haskell Multi-Line Comment

{-
 ${1:Your comment here}
-}

cotrTypeCheck

Haskell Type Check

${1:variable} :: ${2:Type}

cotrTypesBool

Haskell Boolean Type

Bool

cotrVar

Haskell Create Variable

let ${1:myVar} = $2

cotrVarString

Haskell Create String Variable

let ${1:myString} = "${2:Your string here}"

cotrVarInt

Haskell Create Integer Variable

let ${1:myInt} = ${2:0}

cotrForEachLoop

Haskell For Each Loop

forM ${1:iterable} \${2:item} -> do
  -- Your code here

cotrFunc

Haskell Function

${1:functionName} :: ${2:parameterTypes} -> ${3:returnType}
${1:functionName} ${2:parameters} = ${4:expression}

cotrEqual

Haskell Equal To

==

cotrNotEqual

Haskell Not Equal To

/=

cotrInterpolate

Haskell Interpolate String

show ${1:variable}

cotrConcat

Haskell Concatenate Strings

${1:string1} ++ ${2:string2}

cotrVarDate

Haskell Date Variable

-- Use the 'time' package to create a date variable:

import Data.Time

let ${1:myDate} :: UTCTime = getCurrentTime

cotrComment

Haskell Comment

-- ${1:Your comment here}

cotrOperatorsBool

Haskell Boolean Operators

-- Haskell Boolean Operators:

-- - && : Logical AND
-- - || : Logical OR
-- - not : Logical NOT

cotrTypesBoolFalse

Haskell Boolean False

False

cotrGenList

Haskell Generate List

[${1:start}..${2:end}]

cotrPrint

Haskell Print

putStrLn ${1:'Your message here'}

cotrTernary

Haskell Ternary Operator (Alternative)

-- Haskell does not have a ternary operator.
-- Use a case expression or an if-then-else expression instead:

let result = case ${1:condition} of
  True -> ${2:trueValue}
  False -> ${3:falseValue}

cotrThrow

Haskell Throw Exception

error "${1:Your error message here}"

cotrOperators

Haskell Mathematical Operators

-- Haskell Mathematical Operators
-- Addition: +
-- Subtraction: -
-- Multiplication: *
-- Exponentiation: **
-- Division: /
-- Modulus (Remainder): mod
-- Integer Division: div
-- Assignment: =
-- Addition assignment: +=
-- Subtraction assignment: -=
-- Multiplication assignment: *=
-- Division assignment: /=
-- Modulus assignment: mod=
-- Integer Division assignment: div=

cotrTypesDate

Haskell Date Type

-- Haskell does not have a built-in Date type. Use the 'time' package for date and time operations.

cotrVarTyped

Haskell Create Typed Variable

let ${1:myVar} :: ${2:Type} = $3

cotrIf

Haskell If Statement

if ${1:condition}
  then ${2:expression1}
  else ${3:expression2}

cotrVarBool

Haskell Create Boolean Variable

let ${1:myBool} = ${2:True}

cotrForIn

Haskell For…In Loop (Alternative)

-- Haskell does not have a direct for...in loop.
-- Use higher-order functions like 'map' or 'forM' instead:

forM ${1:iterable} \${2:item} -> do
  -- Your code here

cotrTypeCompare

Haskell Type Comparison

-- Haskell does not have a built-in function for comparing types directly.
-- You can use type classes or custom functions to achieve this.

cotrTypes

Haskell Types

$BLOCK_COMMENT_START
Haskell is a statically typed language with strong type inference.

Types in Haskell include:
- Int: Integer
- Integer: Arbitrary-precision integer
- Float: Single-precision floating-point number
- Double: Double-precision floating-point number
- Char: Character
- Bool: Boolean
- String: String
- [a]: List of type 'a'
- (a, b): Tuple with elements of types 'a' and 'b'
- Maybe a: Type representing a value of type 'a' or Nothing
- Either a b: Type representing a value of either type 'a' or type 'b'
- Function types (e.g., Int -> String): Types representing functions
- Data types: Custom data types defined using algebraic data types
- Type classes: Interfaces that define shared behavior for types
$BLOCK_COMMENT_END

cotrTypesMap

Haskell Map Type

Map k v

cotrVarStatic

Haskell Static Variable (Alternative)

-- Haskell does not have static variables in the same way as imperative languages.
-- You can use top-level definitions or modules to achieve similar functionality.

cotrFuncLambda

Haskell Lambda Function

\${1:parameters} -> ${2:expression}

-- Usage example
let ${3:myFunc} = \${1:parameters} -> ${2:expression}
in ${3:myFunc} ${4:arguments}

cotrInfo

Haskell Info

-- Typing: Statically typed, strong, inferred
-- Paradigm: Functional
-- Compilation: Compiled or interpreted
-- Concurrency: Supports concurrency with lightweight threads and software transactional memory

cotrStructure

Haskell Project Structure (High-Level)

// Recommended High-Level Haskell Project Structure:

// - src/
//   - Contains the source code of the application.
//   - Typically organized by functionality or module,
//     with a Main.hs file for the executable entry point.

// - app/
//   - Contains the main application entry point, often linking to the library in src/.

// - lib/
//   - If the project includes a library that should be separable from the main application,
//     its code goes here.

// - test/
//   - Contains the test suites, often using a framework like HUnit or QuickCheck.

// - bench/
//   - Contains benchmarking code, often using a framework like Criterion.

// - doc/
//   - Contains documentation files.

// - scripts/
//   - Contains utility scripts for tasks like building, running, or testing.

// Note:
// - This structure may vary based on the build tool (like Stack or Cabal) and
//   the complexity and needs of the project.
// - The 'app' directory is often used in Stack-based projects.

cotrTypesNull

Haskell Null Type

Nothing

cotrTypesBoolTrue

Haskell Boolean True

True

cotrNow

Haskell Date Now

-- Use the 'time' package to get the current date and time.

cotrTypesNumAlt

Haskell Float Type

Float

cotrConst

Haskell Create Constant

-- Haskell does not have a 'const' keyword. Use 'let' for immutable values.

cotrIfElse

Haskell If-Else Statement

if ${1:condition}
  then ${2:expression1}
  else ${3:expression2}

cotrTryCatch

Haskell Try-Catch

-- Haskell does not have a traditional try-catch mechanism.
-- Use the 'Either' or 'Maybe' types for error handling.

cotrEntry

Haskell Entry Point

-- Haskell Entry Point
-- To run this program, use: `ghc filename.hs` or `runhaskell filename.hs`

main :: IO ()
main = do
  -- Your code here

cotrVarMap

Haskell Create Map Variable

let ${1:myMap} = Map.fromList [(${2:key}, ${3:value})]
  -- Add more key-value pairs here

cotrTypesInt

Haskell Integer Type

Int

cotrSwitch

Haskell Case Expression

case ${1:variable} of
  ${2:pattern1} -> ${3:expression1}
  ${4:pattern2} -> ${5:expression2}
  _ -> ${6:defaultExpression}

cotrFuncArgs

Haskell Function Arguments

-- Haskell functions typically use pattern matching to handle arguments.
-- Example:

myFunction :: Int -> Int -> Int
myFunction x y = x + y

cotrTypesDynamic

Haskell Dynamic Type

-- Haskell is statically typed, but you can use 'Any' for dynamic values.

cotrVarNullable

Haskell Create Nullable Variable

let ${1:myVar} :: Maybe ${2:Type} = Nothing

cotrGenMap

Haskell Generate Map

-- Haskell does not have a built-in way to generate a map with a specific number of key-value pairs.
-- You can use a list comprehension or a custom function to achieve this.

cotrWhileLoop

Haskell While Loop

-- Haskell does not have a traditional while loop. Use recursion or higher-order functions like 'until'.

cotrTypesString

Haskell String Type

String

cotrTypesNum

Haskell Double Type

Double