gdevanla

# coding: utf-8

# Python code to demonstrate the Y-combinator using
# the working example presented by Jim Weirich.
# https://www.infoq.com/presentations/Y-Combinator


def demo():

    fact_1 = lambda n: 1 if n == 0 else (n * fact_1 (n - 1))

gdevanla

;; lambda expression do not have any assignments
;; so we will use the form where there is not lambda expressions

((lambda ()
  (define (adder n) (+ n 1))
  (define (mult3 n) (* n 3))
  (mult3 (adder 10))
  ))

;; create make-adder and compose using higher-order functions

gdevanla

stack unpack $package
cd $package-$version
stack init --resolver nightly
stack build --resolver nightly --haddock --test --bench --no-run-benchmarks

gdevanla

from openpyxl.styles import Alignment

def format_data(index, col_name):
   alignment = Alignment(horizontal=’right’)
   if  col_name == ‘salary’:
      return  dict(
         alignment=alignment,
         number_format='$0.00')

gdevanla

;;; package --- Something here
;;; Commentary:

;;; Code:
(defun get-line-no ()
  "Returns line no of first argument"
  (interactive)
  (let* (lineno)
    (save-excursion
      (start-of-paragraph-text)

gdevanla

-- continuation calling style of functions                                                                                                                                                                                                     
f :: forall a. Integral a => a -> (a -> a) -> a -> a                                                                                                                                                                                           
f y fun x = if x == y then x * x else fun x                                                                                                                                                                                                    
                                                                                                                                                                                                                                               
f_base :: forall a. Num a => a -> a                             

gdevanla

{-# LANGUAGE KindSignatures #-}                                                                                                                                                                                                                
{-# LANGUAGE RankNTypes #-}                                                                                                                                                                                                                    
{-# LANGUAGE OverloadedStrings #-}                                                                                                                                                                                                             
                                                                                                                                                                                                                         
import Control.Concurrent.MVar                                                        

gdevanla

-- sequence a state monad
import Control.Monad.Trans.State

-- Example 1
let y =  do { z <- get; let a = (Prelude.last z) + 1 in put (z Prelude.++ [a]);return $ (Prelude.last z) + 1} :: State [Int] Int
runState (sequenceA [y,y,y]) $ [1]

-- Example: 2
type X = State (M.Map String Int) Int
let y s s1 =  do { z <- get; let a = z M.! s + 1 in put (M.insert s1 a z) ; let a = z M.! s + 1 in return $ a } :: X

gdevanla

-- Adapted from http://chrisdone.com/posts/data-typeable

recordShow :: Data a => a -> ShowS                                                                                                                                                                                                             
recordShow = render `extQ` (shows :: String -> ShowS) where                                                                                                                                                                                    
  render t                                                                                                                                                                                                                                     
    | isTuple = drop 1 . tupleSlots                                                                                                                                                                                                            
    | 

gdevanla

import unittest

def foo(x, y, z):
    return (x != y and x != z or x and z)

def get_test_args():
    x = y = z = [True, False]
    from itertools import product, repeat
    input_args = list(product(x, y, z))
    expected_args = [