fuadsaud

Something I really miss when working with non-Lisp languages is the ability to easily manipulate portions of code programatically.

Vim has, historically, provided text objects as a way to address that need. They're quite useful, but lack awareness of language-specific constructs—those would require a languag-aware parser.

I have recently learned that nvim-treesitter, being particularly well positioned to solve that problem (since it keeps the AST representation), provides some of that functionality natively:

require'nvim-treesitter.configs'.setup {
  incremental_selection = {
    enable = true,

fuadsaud

Keybase proof

I hereby claim:

• I am fuadsaud on github.
• I am fuad (https://keybase.io/fuad) on keybase.
• I have a public key whose fingerprint is 7E48 FEF8 3C3F C2AF 19A2 AF11 A3FC 96BF 4AA8 ADC6

To claim this, I am signing this object:

fuadsaud

module Checkout where

import Data.List

type Price = Integer
type Product = Char
type Cart = [Product]
type Rule = Cart -> Price

total :: Cart -> [Rule] -> Price

fuadsaud

class CheckOut
  def initialize(rules)
    @rules = rules
    @goods = []
  end

  def scan(good)
    goods << good unless good.nil?
  end

fuadsaud

require_relative 'check_out'
require 'minitest/autorun'

class TestPrice < Minitest::Test
  RULES = [
    ModPrice.new('A', 3, 50, 130),
    ModPrice.new('B', 2, 30, 45),
    FixedPrice.new('C', 20),
    FixedPrice.new('D', 15),
  ]

fuadsaud

\documentclass[12pt]{article}

\usepackage{sbc-template}

\usepackage{graphicx,url}

\usepackage[brazil]{babel}
%\usepackage[latin1]{inputenc}
\usepackage[utf8]{inputenc}
% UTF-8 encoding is recommended by ShareLaTex

fuadsaud

import Data.List.Split (splitOn)
import Data.Char (isDigit)
import Data.List (insert, sortBy)
import Data.Function (on)

data Haircut = Haircut { n :: Int, barbers :: [Barber] }

data Barber = Barber { i :: Int, time :: Int, originalTime :: Int } deriving Eq

instance Ord Barber where

fuadsaud

module Dijkstra where

import Data.Char (isDigit)
import Data.Map (Map)
import qualified Data.Map as M

type Q = String

data Dijkstra = Dijkstra Int [Q] deriving Show

fuadsaud

(defn make-composed-comparison [& comparisons]
  (fn [p1 p2]
    (let [results (for [comparison comparisons] (comparison p1 p2))
          first-non-zero-result
          (some (fn [result] (if (not (= 0 result)) result nil)) results)]
      (if (nil? first-non-zero-result)
        0
        first-non-zero-result))))

fuadsaud

PLAINTEXT = ARGV[0].gsub(/[^A-Za-z]/, '')
KEY       = ARGV[1]

p KEY
  .chars
  .cycle
  .take(PLAINTEXT.size)
  .zip(PLAINTEXT.chars)
  .reduce(Hash.new { [] }) { |acc, (key, char)| acc.merge(key => acc[key] + [char]) }
  .to_a