saurabhnanda

Attention

This page has been moved to http://www.vacationlabs.com/haskell-bounty-program

Haskell Internship Bounty Program

Here's the general idea:

• Solve a pre-defined problem (could be an open source contribution OR an internal tool) for a bounty (basically success-fee). Not looking at GSoC level funding or problems, but something that can be done in 1-2 weeks with a 50-250$ bounty.
• Supported by mentoring and general help over slack/IRC.

maksbotan

Generic validation of nested data

TLDR

This technique helps validate arbitrary conditions in deeply nested structures without writing additional code — with the help of Haskell Generics.

It boils down to this pattern:

vrom911

module ChrisPenner where

import Data.Array ((!))
import Data.Foldable (for_, foldl', maximumBy)
import Data.List (sort)
import Data.Map.Strict (Map)
import Data.Ord (comparing)

import qualified Data.Array as A
import qualified Data.Map.Strict as Map

volhovm

So the basic thing you need to start working with org-mode is to install org-mode. Emacs > 24.??? already have it bundled and if you're not going to use some cool features like org-drill and stuff, that should be enough.

Basically, org-mode operates with org files. Create one (work.org for example). Org files' markup is simple -- there are headers with info. Header format is '*'{1..} TODO-kw Description. To create entry just write it. Also C-c RET does something similar (I never use it tho). So, stars are indentation -- more indented

ChrisPenner

#!/bin/bash

if [[ $# -ne 2 ]]; then
    cat >&2 <<EOF
Transplant a branch from one root to another.
Handy if you've done a squash-merge and need to rebase <from> the old branch <onto> the new master.
Usage:
    git transplant <from> <to>

where:

AlexeyRaga

---------------- Базовое ----------------------
type Число = Int
type Строка = Text
type Строчное = Show
type ИО = IO
type Сравнимое = Eq
type Упорядоченное = Ord

печатать :: Строчное значение => значение -> ИО ()
печатать = print

chiroptical

{-# LANGUAGE BlockArguments #-}

module Main where

main :: IO ()
main = do
  babyShark
  do do do do do do babyShark
  do do do do do do babyShark
  do do do do do do babyShark

evincarofautumn

Thoughts on an InlineDoBind extension

An expression beginning with a left arrow (<-) inside a do block statement is desugared to a monadic binding. This is syntactically a superset of existing Haskell, including extensions. It admits a clean notation that subsumes existing patterns and comes with few downsides.

Examples

do
  f (<- x) (<- y)
-- ===

brendanzab

September 2022:

This has spread to a far wider audience than I had anticipated - probably my fault for using a title that is in hindsight catnip for link aggregators. I wrote this back in 2021 just as a bunch of personal thoughts of my experiences using Rust over the years (not always well thought through), and don't intend on trying to push them further, outside of personal experiments and projects.

Managing a living language is challenging and difficult work, and I am grateful for all the hard work that the Rust community and contributors put in given the difficult constraints they work within. Many of the things I listed below are not new, and there's been plenty of difficult discussions about many of them over the years, and some are being worked on or postponed, or rejected for various good reasons. For more thoughts, please see my comment below.

My personal list of Rust gr

kazu-yamamoto

-- | This JSON package retains the order of array elements.
--   JSON: http://www.ietf.org/rfc/rfc4627.txt

module JSON (
    JSON(..)
  , parseJSON
  ) where

import Control.Applicative ((<*),(*>),(<$>),(<$))
import Control.Monad (void)