leobm

Object>>chain
	^ ChainProxy new setTarget: self

ChainProxy>>doesNotUnderstand: aMessage
	target := aMessage sendTo: target.
	^ target

ChainProxy>>setTarget: anObject
	target := anObject.
	^ self

leobm

#[allow(dead_code)]
fn f1(a: i32) -> i32 {
    a    
}
#[allow(dead_code)]
fn f2(a: i32, b: i32) -> i32 {
    a+b
}

#[allow(dead_code)]

leobm

macro_rules! avg {
    ($($t:expr),*) => (sum!($($t),*)/count!($($t),*));
}

macro_rules! count {
    ($h:expr) => (1);
    ($h:expr, $($t:expr),*) =>
        (1 + count!($($t),*));
}

leobm

import writer
import string_writer

pub fn main() {
  string_writer.create()
  |> writer.write("Text1")
  |> writer.write("Text2")
  |> string_writer.print()
}

leobm

defmodule MyApp do
  use Application

  def start(_type, _args) do
    import Supervisor.Spec, warn: false

    children = [
      Plug.Adapters.Cowboy.child_spec(:http, MyApp.Router, [], [
        dispatch: dispatch
      ])

leobm

; Ruby has an awesome feature -- string interpolation. Read about it on the internet.
; On the other hand, Clojure only has cumbersome Java string formatting, which can not be
; used without pain after you've tried Ruby.

; So here's this simple macro that basically allows you to do most things you could do
; with Ruby string interpolation in Clojure.

(ns eis.stuff
  (:require [clojure.string]))

leobm

// ==UserScript==
// @name		Delete youtube comments activity
// @version		1
// @grant		none
// @include		https://myactivity.google.com/page*
// ==/UserScript==

const DELETE_MAX_ENTRIES_AFTER_PAGE_RELOAD = 1;

(function(d) {

leobm

module Main where

import Prelude

import Control.Monad.Reader (Reader, runReader, ReaderT(..), runReaderT, ask, class MonadAsk)
import Effect (Effect)
import Effect.Class (class MonadEffect, liftEffect)
import Effect.Console (log)

---------------------------------------------------------

leobm

-- an example of how to derive a show instance for a Maybe type
-- not totally sure why `derive instance showMyMaybe :: (Show a) => Show (MyMaybe a)` errors with...
-- error: CannotDerive :
-- Cannot derive a type class instance for Data.Show.Show (MyMaybe a) since instances of this type class are not derivable.
module Main where

import Prelude

import Control.Monad.Eff (Eff)
import Control.Monad.Eff.Console (CONSOLE, log)

leobm

import Text.ParserCombinators.Parsec
import Data.List

type Args = [String]
type Body = [String]
type Label = String

data JSONProp = JSONProp Label JSON deriving Show
data JSON = JSONObject [JSONProp] 
          | JSONNumber Double