1 / 46

TeSLa

research. product. TeSLa. Why The $@#%! Visual Basic. Imports SySTem.STriNg Module Demo Public Sub Main() Dim S = Join( ", " , { "Hello" , "World" }) End Sub End Module. Case insensitive. Class imports. Static class. Why The $@#%! Visual Basic. Class Dog

fayola
Download Presentation

TeSLa

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. research product TeSLa

  2. Why The $@#%! Visual Basic Imports SySTem.STriNg Module Demo Public Sub Main()Dim S = Join(", ", { "Hello", "World"}) End Sub End Module Case insensitive Class imports Static class

  3. Why The $@#%! Visual Basic Class Dog Public Event Bark()End Class Dim WithEvents D As New Dog() Sub OnBark() Handles D.Bark Console.WriteLine("Call 911") End Sub DeclarativeEvent Handling "AOP"

  4. Why The $@#%! Visual Basic Optional parameters Function F(X As Integer, _Optional Flag As Boolean = False) _As String …End Function F (Flag := True, X := 4711) Named arguments

  5. Why The $@#%! Visual Basic Class Dog Public Event Bark()Public Default Property Toys(Name As String) _As ObjectGet… End GetSet (Value As Object) …End Set End PropertyEnd Class Line continuations Indexed Properties

  6. Why The $@#%! Visual Basic With Statement Dim D As New Dog() With D .Toys("Bone") = New Bone() .Toys!Cat = CatchNeighboursCat() Console.WriteLine(.Toys("Ball").Color) End With Late binding Late binding With Scope(Power is in the ".")

  7. Late Binding K = J+3 For I=0 To 10 Console.WriteLine(I)Next Dim X As String = 4711 Function F(X) Return X+3End Function Option Implicit Implicit Explicit Conversions Types Optional

  8. Relaxed delegates DimWithEvents B As New Button()Sub OnClick(sender As Object, e As EventArgs) _Handles B.Click End SubSub RelaxedOnClick(sender As Object, e As Object) _ Handles B.Click End Sub Can call it  can handle it

  9. Relaxed delegates DelegateFunction F(A As S) As T Function G(B As P) As Q New F(AddressOf G)  New F(Function(A)CType(G(CType(A,P)),T) Conversion stub

  10. Why The $@#%! Visual Basic Extension Methods <Runtime.CompilerServices.Extension()> _ Function FindName(Source As Object, Name As String) As Object On Error Resume Next If Source.Name = Name Then Return Source End If Dim Children As Object = Source.Children If Children IsNot Nothing Then For Each Child As Object In Children FindName = FindName(Child, Name) If FindName IsNot Nothing Then Return FindName End If Next End If Return Nothing End Function Unstructured Exception Handling Late binding "AOP"

  11. Late Binding! Type Rule For Early-BoundMethod Invocation G |- e As S ~~> e’G |- a As T ~~> a’S•m(T) As R ~~> f----------------------------------G |- e.m(a) As R ~~> f(e’,a’)

  12. Late Binding! Type Rule For Late-BoundMethod Invocation G |- e As Object ~~> e’G |- a As T ~~> a’T <: Object ~~> g-----------------------------G |- e.m(a) <: Object ~~> latecall("m", e’, g(a’))

  13. Late Binding! Operational Semantics For Late-Bound Call s.GetType()  S, t.GetType()  TS•m(T) <: R ~~> fR <: Object ~~> h----------------------------latecall(m,s,t)  h(f(s,t)) VB has multi-methods!

  14. Late Binding Class A Sub F(X As String)WriteLine("F(String)") End Sub Sub F(X As Object)WriteLine("F(Object)") End Sub Sub Main() Dim A = New A() Dim S As Object ="Hello"A.F(S)REM Early  F(Object)CObj(A).F(S)REM Late  F(String) End Sub End Class Imports System.Console Type Inference

  15. Meta-circular interpreter ℰ[A+B] = Add(ℰ[A], ℰ[B]) ℰ[A.m(B) ] = Call(ℰ[ m ], ℰ[A], ℰ[B]) Self interpretation is litmus test for dynamic language

  16. Replace Constants By Variables G |- e <: Object ~~> e’G |- a <: T ~~> a’T <: Object ~~> f G |- m <: String ~~> m'------------------------------------------------------G |- e.(m)(a) <: Object ~~> latecall(m', e’, f(a’)) Later binding

  17. Later Binding Class A Sub F(X As String)WriteLine("F(String)") End Sub Sub F(X As Object)WriteLine("F(Object)") End Sub Sub Main() Dim A = New A() Dim S As Object ="Hello"A.(Console.ReadLine())(S) End Sub End Class

  18. VB as the ultimate scripting language Static Typing Where PossibleDynamic Typing Where Necessary

  19. Ruby e = 8 + 9 \ + 10 d = 4 + 5 + 6 + 7 def options(a=99, b=a+1) [a,b]end redirect_to :action => 'show', :id => 4711 Line continuation Smart "inference" Default arguments Named arguments via hashes

  20. LINQ Project == monad comprehensions in C# & VB VB 9 C# 3.0 … StandardQueryOperators DLinq(relational) XLinq(xml) LINQ Framework

  21. The Origins of LINQ Swartz, SETL 1970; Burstall and Darlington, NPL 1977; Turner, KRC 1981; …. Haskell, Python, Scala, … Write programs using mathematical ZF set comprehensions syntax. Wadler 1989 List comprehensions are related to the relational calculus. Wadler 1992 List comprehensions are a special case of monad comprehensions.

  22. HaskellDb Query Monad (1997) SELECT X.FirstName, X.LastName FROM Authors AS X WHERE X.City = 'OakLand' oaklands = do{ x <- table authors ; restrict (x!city .==. constant "Oakland") ; project ( au_fname = x!au_fname , au_lname = x!au_lname ) } Query monad intentional representation for expressions

  23. Query Comprensions In C# 3.0 var contacts = from c in customers where c.State == "WA" selectnew { c.Name, c.Phone }; var contacts = customers .Where(c => c.State == "WA") .Select(c => new{c.Name, c.Phone}); Type inference Syntactic sugar over standard query operations -expression

  24. Query Comprensions In Visual Basic 9 Dim Squares = From N In Range(0,99) Select N*N Dim Pairs = From N In Range(0,9) From C In "ABCDEFGHIJ" Select N, C Dim Evens = From N In (0,99)Where N Mod 2 = 0Select N Dim ByDigit = From N In (0,99)Group By N Mod 10Select Key, It

  25. In Visual Basic 9 Dim Contacts = From C In Customers Where C.State = "WA" Select C.Name, C.Phone Dim Contacts = _ Customers. Where(Function(C) C.State = "WA"). Select(New With { .Name = C.Name, .Phone = C.Phone })

  26. Query Comprensions In Visual Basic 9 Dim MyCDs As IEnumerable(Of _ { Title As String, Artist As String }) = _ From CD In MyMusic Where CD.Genre IsNot Classic Group By Genre = CD.Genre Where Count(CD) > 10 Select Group(CD.Title, CD.Artist) Aggregate comprehensions

  27. Query Comprehensions Xs.SelectMany((X) _ F(X).Select((Y)_New {X,Y})) X From Y In F(X) Compiled To Standard Query Operators X,Y Joined

  28. Query Comprehensions XYs.OrderBy((XY) _ F(XY.X, XY.Y)) X,Y Order By F(X,Y) X,Y Sorted

  29. Query Comprehensions X,Y XYs.Where((XY) _ P(XY.X, XY.Y)) Where P(X,Y) X,Y Filtered

  30. Query Comprehensions X,Y projected Select A =F(X,Y), B = G(X,Y) A,B XYs.Select((XY) _ New {A = F(XY.X, XY.Y), _ B = F(XY.X, XY.Y) })

  31. Query Comprehensions XYs.GroupBy((XY) _ New {A = G(XY.X, XY.Y), _ B = H(XY.X, XY.Y) }) X,Y Group By A = G(X,Y), B = H(X,Y) A,B, grouped X,Y

  32. Extension Methods static classInteger { static void Times (this int x, Action<int> f){ for(var i = 0; i < x; i++) f(i); } 3.Times((x) => {Console.WriteLine(x); }

  33. Extension Methods IEnumerable<Customer> var contacts = customers .Where(c => c.State == "WA") .Select(c => new{c.Name, c.Phone}); static class System.Query { public static IEnumerable<T> Where<T>(this IEnumerable<T> src, Func<T, bool>> p); … } Extension method for IEnumerable<T>

  34. In Visual Basic 9 Dim Contacts = _ Customers.Where(P).Select(R) Module MyExtensions<Runtime.CompilerServices.Extension()> _ Function Where(Of T)( _ [Me] As IEnumerable(Of T), _ P As Func(Of T, Boolean)) _As IEnumerable(Of T) … End Module Just CA

  35. Expression Trees Table<Customer> var contacts = customers .Where(c => c.State == "WA") .Select(c => new{c.Name, c.Phone}); class Table<T>: IEnumerable<T> { public Table<T> Where(Expression <Func<T, bool>> p); … } Intensional representation of delegate

  36. Expression Trees Convert to expression tree by type Dim F As Expr = Function(X)X+3Dim G = F.Compile()Dim Z = G(5) Compile to delegate Execute

  37. Anonymous types,Object initializers var contacts = from c in customers where c.State == "WA" selectnew { c.Name, c.Phone }; var Joe = new Person{ Name = “Joe”, Age = 42, Address = { Street = “1th St”, City = “Seattle” }} Anonymous types Object Initializers Initialize RO member

  38. In Visual Basic 9 Dim Contacts As IEnumerable(Of _ { Name As String, Phone As Integer } = From c In customers _ Where C.State == "WA“ _ Select c.Name, c.Phone Dim Joe As Person = New With { _ .Name = “Joe”, .Age = 42, _ Address With { _ .Street = “1th St”, .City = “Seattle” }} Anonymous types Syntax new

  39. Nullable Dim S1 As String? = Nothing Dim S2 As String? = “Hello” Dim S3 = S1+S2 Null propagating + In VB Nothing is default

  40. XML DOM Dim PO As New XmlDocument Dim purchaseOrder As XmlElement = _ PO.CreateElement("purchaseOrder") PO.AppendChild(purchaseOrder) Dim orderDate As XmlAttribute = PO.CreateAttribute("orderDate") orderDate.Value = "1999-10-20" purchaseOrder.Attributes.Append(orderDate) Dim shipTo As XmlElement = PO.CreateElement("shipTo") purchaseOrder.AppendChild(shipTo) Dim country As XmlAttribute = PO.CreateAttribute("country") country.Value = "US" shipTo.Attributes.Append(country) What does this program do?

  41. XLinq API Functional (expression-based) construction Dim Item = _New XElement("item", _ New XAttribute("partNum", "926-AA"), _ New XElement("productName", “…"), _ New XElement("quantity", 1), _ New XElement("price", 39.98), _ New XElement("shipDate", "1999-05-21")))) Context-free (no document scope) Simple

  42. Haskell Server Pages XHTML Literals (1998) table :: TABLE table = <TABLE border="1"> <% mkRows cells %> </TABLE> cells :: [[(Int,Int)]] cells = [[ (x,y) | x <- [1..16] ] | y <- [1..16] ] mkRows :: [[(Int,Int)]] -> [TR] mkRows = map $ \cs -> <TR><% mkColums cs %></TR> mkColumns :: [(Int,Int)] -> [TD] mkColums = map $ \c -> <TD bgcolor=(color c)><% c %></TD> Translated to universal DOM representation ASP-style embedding

  43. Dim PO = <purchaseOrder orderDate=(System.DateTime.Today)> <shipTo country="US"> <name>Alice Smith</name> <street>123 Maple Street</street> <city>Mill Valley</city> <state>CA</state> <zip>90952</zip> </shipTo> <%= BillTo %> <items> <%= Select<itempartNum=<%= O.PartID %>> <productName> <%= O.Product %> </productName> <quantity> <%= O.Quantity %> </quantity> <price> <%= O.Price %> </price> </item> From O In Orders Where O.Name = "Robert Smith" %> </items> </purchaseOrder> Translated to XLinq constructor calls ASP-style embedding Includes full namespace support

  44. Late binding over XML Child axis BillTo.<street>  BillTo.Elements(“street”) Attribute axis BillTo.@country BillTo.Attributes(“country”) Descendants axis PO...<item>  PO.Descendants(“item”)

  45. Tesla • Tools & IDE • Type system & Language extensions • Runtime & Library support • Transactions everywhere

  46. Conclusion VB IsNot C# VB = static typing where possible, dynamic typing where necessary.

More Related