rougier

;; Dual header line is possible by exploiting the tab-bar line that
;; sits on top of the header line and is generally hidden. For the
;; icon, it has to be precisely cut in top and bottom part and each
;; part is concatenated with either the tab-line or header-line.

(defun dual-header (top bottom)
  "This installs a double line header in current buffer using both tab line (TOP) and header line (BOTTOM)."

  (set-face-attribute 'tab-line (selected-frame)

gpeal

class WifiNetworksFragment : TonalFragment(R.layout.wifi_networks_fragment) {
    // This automatically creates and clears the binding in a lifecycle-aware way.
    private val binding: WifiNetworksFragmentBinding by viewBinding()
  
  ...
}

class WifiNetworkView @JvmOverloads constructor(
    context: Context,
    attrs: AttributeSet? = null,

Terenfear

import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.Job
import kotlinx.coroutines.delay
import kotlinx.coroutines.launch

/*
This is free and unencumbered software released into the public domain.

Anyone is free to copy, modify, publish, use, compile, sell, or
distribute this software, either in source code form or as a compiled

freetonik

(defun org-mode-export-myfile ()
  "Export org document to HTML automatically on change"
  (when (equal (buffer-file-name) "/path/to/links.org")
    (progn
      (org-html-export-to-html)
      (message "HTML exported"))))

(add-hook 'after-save-hook 'org-mode-export-myfile)

alphapapa

;; Moved to dedicated repo: https://github.com/alphapapa/snow.el

radlinskii

#!/bin/sh

STAGED_GO_FILES=$(git diff --cached --name-only | grep ".go$")

if [[ "$STAGED_GO_FILES" = "" ]]; then
  exit 0
fi

GOLINT=$GOPATH/bin/golint
GOIMPORTS=$GOPATH/bin/goimports

masahirompp

export function imageFileToDataUri (file: File) {
  return new Promise<string>(done => {
    const reader = new FileReader()
    reader.onloadend = () => done(reader.result)
    reader.readAsDataURL(file)
  })
}

export function imageSrcToImageData (imageSrc: string) {
  return new Promise<ImageData>(resolve => {

masahirompp

declare module 'react-svg-pan-zoom' {

  import * as React from 'react'

  type Tool = 'auto' | 'none' | 'pan' | 'zoom-in' | 'zoom-out'
  type ToolBarPosition = 'none' | 'top' | 'right' | 'bottom' | 'left'

  export const ReactSVGPanZoom: ReactSVGPanZoom

  interface ReactSVGPanZoom extends React.ComponentClass<ReactSVGPanZoomProps> {}

TuxCoding

public class AnnotationHelper {
    private static final String ANNOTATIONS = "annotations";
    public static final String ANNOTATION_DATA = "annotationData";
 
    public static boolean isJDK7OrLower() {
        boolean jdk7OrLower = true;
        try {
            Class.class.getDeclaredField(ANNOTATIONS);
        } catch (NoSuchFieldException e) {
            //Willfully ignore all exceptions

cobalamin

• Types are declared with : and not ::, and the consing operator conversely is :: instead of :
• No where clauses, only let/in
• The standard style is different, check http://elm-lang.org/docs/style-guide for reference
• Multiline strings are a thing with """
• Haskell's data corresponds to type in Elm, and also, Haskell's type corresponds to Elm's type alias
• ($) is (<|), but you don't use it all that much – Elm people like the flipped operator (|>) which lets you build something that reads like a pipeline
• Related: Backticks will likely die soon in favour of functions that have an argument order that lends itself to pipelining with (|>)
• Also, (.) is (<<), and a flipped version (>>) exists, but I don't see it used that much either
• (>>=) is not an available operator and would not be polymorphic (no typeclasses, see below), and is instead commonly named SomeType.andThen – e.g. Maybe.andThen : Maybe a -> (a -> Maybe b) -> Maybe b