A little fold-up joystick brings haptics to portable devices
The tactile joystick developed by startup Foldaway Haptics brings the sense of touch to mobile devices © 2018 Alain Herzog The tactile joystick developed by startup Foldaway Haptics brings the sense of touch to mobile devices, drones and, in a smaller version, to virtual reality controls. This pocket-sized device, which can be unfolded in an instant, is about to hit the market. Next week it will b
A new JPEG format for virtual reality, drones and self-driving cars
A new JPEG format for virtual reality, drones and self-driving cars The Joint Photographic Experts Group (JPEG), an international committee headed by an EPFL professor, has just unveiled JPEG XS. With this new format, the image-compression process uses less energy, and higher-quality images can be sent with low latency over broadband networks like 5G. JPEG XS will have applications in areas such a
2015-2018 Linked Books (FNS) – DHLAB
We explore the history of Venice through citations, and build a web application to navigate through the resulting network of references, with the final aim of interlinking digital archives and digital libraries. For this goal we developed a system to automatically extract citations from a large set of digitized books and journals on the history of Venice. We are specifically interested in analyzin
Erased Terms
Why erased terms? The following examples shows an implementation of a simple state machine which can be in a state On or Off. The machine can change state from Off to On with turnedOn only if it is currently Off. This last constraint is captured with the IsOff[S] implicit evidence which only exists for IsOff[Off]. For example, not allowing calling turnedOn on in an On state as we would require an
Implicit By-Name Parameters
Call-by-name implicit parameters can be used to avoid a divergent implicit expansion. trait Codec[T] { def write(x: T): Unit } implicit def intCodec: Codec[Int] = ??? implicit def optionCodec[T] (implicit ev: => Codec[T]): Codec[Option[T]] = new { def write(xo: Option[T]) = xo match { case Some(x) => ev.write(x) case None => } } val s = implicitly[Codec[Option[Int]]] s.write(Some(33)) s.write(None
Changes in Implicit Resolution
Implicit resolution uses a new algorithm which caches implicit results more aggressively for performance. There are also some changes that affect implicits on the language level. Types of implicit values and result types of implicit methods must be explicitly declared. Excepted are only values in local blocks where the type may still be inferred: class C { val ctx: Context = ... // ok /*!*/ implic
Implicit Conversions
An implicit conversion, also called view, is a conversion that is applied by the compiler in several situations: When an expression e of type T is encountered, but the compiler needs an expression of type S. When an expression e.m where e has type T but T defines no member m is encountered. In those cases, the compiler looks in the implicit scope for a conversion that can convert an expression of
Option-less pattern matching
Dotty implementation of pattern matching was greatly simplified compared to scalac. From a user perspective, this means that Dotty generated patterns are a lot easier to debug, as variables all show up in debug modes and positions are correctly preserved. Dotty supports a superset of scalac's extractors. Boolean Pattern Extractor defines def unapply(x: T): Boolean Pattern-matching on exactly 0 pat
Automatic Eta Expansion
Previously, a method reference m was converted to a function value only if the expected type was a function type. If that was not the case, one had to write m _ to force the conversion (which is called eta-expansion). For methods with one or more parameters, this restriction has now been dropped. Example: def m(x: Boolean, y: String)(z: Int): List[Int] val f1 = m val f2 = m(true, "abc") This creat
Auto-Application
Previously an empty argument list () was implicitly inserted when calling a nullary method without arguments. E.g. def next(): T = ... next // is expanded to next() In Dotty, this idiom is an error. next ^ missing arguments for method next In Dotty, the application syntax has to follow exactly the parameter syntax. Excluded from this rule are methods that are defined in Java or that override metho
Obsolete page
This hosting infrastructure is being phased-out by EPFL. You should be automatically redirected to https://fleuret.org/ee559/.
Services for EPFL researchers and PhD students
Publishing support The Library offers its expertise and its support during all publication processes, from the writing to the diffusion of the research output. Publishing Support Fast Guides Open Access: the basics | Make your research open | Creative Commons Licenses | Publishing agreement | Exception for educational purposes | How to reuse a work properly
Dependent Function Types
A dependent function type describes functions where the result type may depend on the function's parameter values. Example: trait Entry { type Key; val key: Key } def extractKey(e: Entry): e.Key = e.key // a dependent method val extractor: (e: Entry) => e.Key = extractKey // a dependent function value // ║ ⇓ ⇓ ⇓ ⇓ ⇓ ⇓ ⇓ ║ // ║ Dependent ║ // ║ Function Type ║ // ╚═══════════════════╝ Scala already
Microelectronic Systems Laboratory | EPFL
Breadcrumb navigation EPFL STI Microelectronic Systems Laboratory Language switcher English The Microelectronic Systems Laboratory (LSM) at EPFL operates as a part of the Institute of Electrical Engineering (IEL), concentrating its activities on the design and implementation of high-performance digital and mixed-signal VLSI circuits, language-based modeling and validation of SoC components, neurom
Two Approaches to Portable Macros
Two Approaches to Portable Macros Fengyun Liu EPFL fengyun.liu@epfl.ch Eugene Burmako Twitter, Inc. eburmako@twitter.com Abstract For any programming language that supports macros and has multiple implementations (each with different AST def- initions), there is a common problem: how to make macros that operate on ASTs portable among different compiler imple- mentations? Implementing portable macr
Unification of Compile-Time and Runtime Metaprogramming in Scala
POUR L'OBTENTION DU GRADE DE DOCTEUR ÈS SCIENCES acceptée sur proposition du jury: Prof. J. R. Larus, président du jury Prof. M. Odersky, directeur de thèse Dr D. Syme, rapporteur Prof. S. Tobin-Hochstadt, rapporteur Prof. V. Kuncak, rapporteur Unification of Compile-Time and Runtime Metaprogramming in Scala THÈSE NO 7159 (2017) ÉCOLE POLYTECHNIQUE FÉDÉRALE DE LAUSANNE PRÉSENTÉE LE 6 MARS 2017 À L
1
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
People - EPFL
https://documents.epfl.ch/users/f/fl/fleuret/www/dlc/dlc-slides-9-autoencoders.pdf
Scala Macros: Let Our Powers Combine! - On How Rich Syntax and Static Types Work with Metaprogramming
http://lara.epfl.ch/~kuncak/papers/SchmidKuncak16CheckingPredicate.pdf