dhilst

module Foo where

import           Control.Monad.State
{-# ANN module ("hlint: ignore Use <$>") #-}
-- This ^ line disables it 


foo :: State Int String
foo = do
  x <- get

dhilst

using System;

namespace TodoApi
{
    /// <summary>
    /// A generic result class that should enough
    /// to get rid of exceptions and be general enough
    /// for handling all kind of errors.
    ///
    /// User is forced to handle error case to get success

dhilst

function MyClass() abort
  let this = {}

  function this.setA() dict
    let self.a = 1100
  endfunc

  function this.method() dict
    return self.a
  endfunc

dhilst

nums = [
    (lambda f, x: x),
    (lambda f, x: f(x)),
    (lambda f, x: f(f(x))),
]


result = 0
calls = []
def f(x):

dhilst

class sym:
    def __init__(self, name):
        self.name = name

    def __str__(self):
        return f":{self.name}"


def builtin_func(name):
    def inner(f):

dhilst

from ast import (
    NodeTransformer,
    arguments,
    arg,
    Lambda,
    parse,
    In,
    Call,
    Expression,
    fix_missing_locations,

dhilst

import sys
from sly import Lexer, Parser  # type: ignore
from collections.abc import Iterable

# lamb -> LAMB ID DOT term
# lamb -> appl
# appl -> appl term
# appl -> term
# term -> LPAR lamb RPAR
# term -> ID

dhilst

import sys
from sly import Lexer, Parser
from collections.abc import Iterable

# lamb -> LAMB ID DOT term
# lamb -> appl
# appl -> appl term
# appl -> term
# term -> LPAR lamb RPAR
# term -> ID

dhilst

eval((λx.x) 1)
  eval((λx.x))
  eval(1)
  appl((λx.1), 1) => 1

eval((λx.(λy.x)) 1 2)
  eval((λx.(λy.x)) 1)
    eval((λx.(λy.x)))
    eval(1)
    appl((λx.(λy.1)), 1) => (λy.1)

dhilst

#!/Users/gecko/code/deployment/minsible
- debug: